package de.javakicker;

/**
 * The Class SoccerAction.
 *
 * @author Hendrik Dahlkamp
 * @author Mathias Retzlaf
 */

public final class SoccerAction
{
	
	/** Symbolische Konstante fuer 'Keine Aktion'. */
	public static String NOTHING = "nothing";
	
	/** Symbolische Konstante fuer 'Bewegen'. */
	public static String MOVE = "move";
	
	/** Symbolische Konstante fuer 'Rennen'. */
	public static String RUN = "run";
	
	/** Symbolische Konstante fuer 'Dribbeln'. */
	public static String DRIBBLE = "dribble";
	
	/** Symbolische Konstante fuer 'Passen'. */
	public static String PASS = "pass";

	/** The action. */
	private String action = NOTHING;

	/** The direction. */
	private int direction = 0;

	/**
	 * Instantiates a new soccer action.
	 *
	 * @param action the action
	 * @param direction the direction
	 */
	SoccerAction(String action, int direction)
	{
		this.action = action;
		this.direction = direction;
	}

	/** Liefert den Typ dieser Aktion.
	 * @return Der Typ der Aktion. Eine der Konstanten <code>NOTHING</code>, 
	 *         <code>MOVE</code>, <code>RUN</code>, <code>DRIBBLE</code> oder
	 *         <code>PASS</code>.
	 */
	public String getAction()
	{ return action; }

	/** Setzt den Typ dieser Aktion.
	 * @param action Der Typ der Aktion. Eine der Konstanten <code>NOTHING</code>, 
	 *         <code>MOVE</code>, <code>RUN</code>, <code>DRIBBLE</code> oder
	 *         <code>PASS</code>.
	 */
	public void setAction(String action)
	{ this.action = action; }

	/** Liefert die Richtung, in die die Aktion ausgefuehrt wird. Wie diese genau
	 * interpretiert wird, haengt vom Typ der Aktion ab.
	 * @return die Richtung der Aktion
	 */ 
	public int getDirection()
	{ return direction; }

	/** Setzt die Richtung, in die die Aktion ausgefuehrt wird. Wie diese genau
	 * interpretiert wird, haengt vom Typ der Aktion ab.
	 * @param direction die Richtung der Aktion
	 */ 
	public void setDirection(int direction)
	{ this.direction = direction; }

	/** Erzeugt eine "Bewegen"-Aktion.
	 * @param direction die Richtung, in die der Roboter sich bewegen soll
	 * @return eine <code>SoccerAction</code>, die die Bewegung enth�lt
	 */
	public static SoccerAction move(int direction)
	{
		return new SoccerAction(MOVE, direction);
	}

	/** Erzeugt eine "Rennen"-Aktion.
	 * @param direction die Richtung, in die der Roboter rennen soll
	 * @return eine <code>SoccerAction</code>, die die Bewegung enth�lt
	 */
	public static SoccerAction run(int direction)
	{
		return new SoccerAction(RUN, direction);
	}

	/** Erzeugt eine "Passen"-Aktion.
	 * @param direction die Richtung, in die der Roboter den Ball passen soll
	 * @return eine <code>SoccerAction</code>, die die Aktion enthaelt
	 */
	public static SoccerAction pass(int direction)
	{
		return new SoccerAction(PASS, direction);
	}

	/** Erzeugt eine "Dribbeln"-Aktion.
	 * @param direction die Richtung, in die der Roboter den Ball dribbeln soll
	 * @return eine <code>SoccerAction</code>, die die Aktion enthaelt
	 */
	public static SoccerAction dribble(int direction)
	{
		return new SoccerAction(DRIBBLE, direction);
	}

	/** Erzeugt eine leere Aktion. Dies kann verwendet werden, damit ein Roboter
	 * gar nichts tut bzw. einfach stehenbleibt.
	 * @return eine "leere" <code>SoccerAction</code>.
	 */
	public static SoccerAction nothing()
	{
		return new SoccerAction(MOVE, Player.NOTHING);
	}

	
	/** Liefert eine String-Repraesentation der Aktion. Diese besteht aus der eigentlichen
	 * Aktion, gefolgt von der Richtung, in Kleinbuchstaben, z.B. <code>"move up"</code>
	 * oder <code>"dribble right"</code>.
	 * @return eine String-Repraesentation der Aktion.
	 */
	public String toString()
	{
		String directionString = null;
		switch (direction)
		{
			case Player.UP: directionString = " up"; break;
			case Player.DOWN: directionString = " down"; break;
			case Player.LEFT: directionString = " left"; break;
			case Player.RIGHT: directionString = " right"; break;
		}

		return action + directionString;
	}
	
	/** Vergleicht zwei Aktionen.
	 * @param o eine andere <code>SoccerAction</code>
	 * @return <code>true</code>, falls <code>o</code> vom Typ <code>SoccerAction</code> ist
	 *         und die beiden Objekte die selbe Aktion beschreiben; sonst <code>false</code>.
	 */
	public boolean equals(Object o)
	{
		return (o instanceof SoccerAction) &&
			((SoccerAction) o).action == this.action &&
			((SoccerAction) o).direction == this.direction;
	}
}
